import { Plugin } from './formulaCore.js';
export class SumPlugin extends Plugin {
    constructor() {
        super();
        this.name = 'SUM';
    }

    is2DArray(arr) {
        // 检查是否是数组
        if (!Array.isArray(arr)) {
            return false;
        }
    
        // 空数组也算二维数组
        if (arr.length === 0) {
            return true;
        }
    
        // 检查每一项是否也是数组
        return arr.every(item => Array.isArray(item));
    }

    execute(args) {
        console.log(args,'args')
        if(this.is2DArray(args)){
            return args.reduce((sum, value) => {
                let s = 0;
                value.forEach(item => {
                    // 获取对象的键值对
                    const key = Object.keys(item)[0]; // 例如 "B2"
                    const value = item[key];          // 例如 1 或 "公式参数字段2："
            
                    // 判断是否为数字
                    if (typeof value === 'number') {
                        sum += value; // 如果是数字，直接累加
                    } else if (!isNaN(parseFloat(value))) {
                        s += parseFloat(value); // 如果是字符串数字，转换为数字后累加
                    } else {
                        s += 0; // 如果不是数字，取 0
                    }
                });
                return sum+s
            }, 0);
        }else{
            let s = 0;
            args.forEach(item => {
                // 获取对象的键值对
                const key = Object.keys(item)[0]; // 例如 "B2"
                const value = item[key];          // 例如 1 或 "公式参数字段2："
        
                // 判断是否为数字
                if (typeof value === 'number') {
                    s += value; // 如果是数字，直接累加
                } else if (!isNaN(parseFloat(value))) {
                    s += parseFloat(value); // 如果是字符串数字，转换为数字后累加
                } else {
                    s += 0; // 如果不是数字，取 0
                }
            });
            return s
        }
        
    }
}

export class TestPlugin extends Plugin {
    constructor() {
        super();
        this.name = 'TEST';
    }

    execute(args) {
        console.log(args,'test plugin');
        return args[0];
    }
}

export class VLookUpPlugin extends Plugin {
    constructor() {
        super();
        this.name = 'VLOOKUP';
    }

    execute(args) {
        //let dataList = args;
        console.log(args,'args===VLOOKUP')
        let lookupValue = args[0]
        let tableArray =args[1]
        let colIndex = args[2]
        let rangeLookup = false
        if (!Array.isArray(tableArray) || tableArray.length === 0) {
            throw new Error("数据必须是非空数组");
        }
        if (typeof lookupValue !== "string") {
            throw new Error("查找值必须是字符串");
        }
        if (typeof colIndex !== "number" || colIndex < 1) {
            throw new Error("列索引必须是大于等于 1 的数字");
        }

        // 将数据转换为二维数组形式
        const table = tableArray.map((item) => {
            const key = Object.keys(item)[0];
            const value = item[key];
            return [key, value];
        });
        console.log(table,'table===VLOOKUP')
        let backData = '#N/A'
        // 查找逻辑
        if (rangeLookup) {
            // 近似匹配（要求查找列已排序）
            backData = this.approximateMatch(table, lookupValue, colIndex);
        } else {
            // 精确匹配
            backData = this.exactMatch(table, lookupValue, colIndex);
        }
            
        console.log(backData,'backData===VLOOKUP')
        return backData.toString()
   


       
    }


        // 精确匹配
    exactMatch(table, lookupValue, colIndex) {
        for (const row of table) {
        if (row[1] === lookupValue) {
            return this.getColumnValue(table, row[0], colIndex);
        }
        }
        return null; // 未找到
    }
    
  // 近似匹配
   approximateMatch(table, lookupValue, colIndex) {
    let bestMatch = null;
    for (const row of table) {
      if (row[1] <= lookupValue) {
        bestMatch = row;
      } else {
        break; // 查找列已排序，后续值更大，无需继续
      }
    }
    return bestMatch ? this.getColumnValue(table, bestMatch[0], colIndex) : null;
  }
  
  // 获取指定列的值
   getColumnValue(table, rowKey, colIndex) {
    const row = table.find((item) => item[0] === rowKey);
    if (!row) return null;
  
    // 解析列字母（如 "A1" -> "A"）
    const columnLetter = rowKey.match(/[A-Za-z]+/)[0];
    const targetColumn = String.fromCharCode(columnLetter.charCodeAt(0) + colIndex - 1);
  
    // 构造目标 key（如 "B1"）
    const targetKey = `${targetColumn}${rowKey.match(/\d+/)[0]}`;
  
    // 查找目标值
    const targetRow = table.find((item) => item[0] === targetKey);
    return targetRow ? targetRow[1] : null;
  }

    
    

}
export class RightPlugin extends Plugin {
    constructor() {
        super();
        this.name = 'RIGHT';
    }

    execute(args) {
        console.log(args,'args');
        // 获取对象的键值对
        const key0 = Object.keys(args[0])[0]; // 例如 "B2"
        const value0 = args[0][key0];          // 例如 1 或 "公式参数字段2："
        const value1 = args[1];          // 例如 1 或 "公式参数字段2："
        let str = '';
        str = String(value0);//转字符串
        // 确保numChars是一个非负整数，并且不超过字符串的长度
        let numChars = Math.max(0, Math.min(value1, str.length));
        console.log(str.slice(-numChars),'str.slice(-numChars)');
        // 使用slice方法从字符串的右侧开始提取指定数量的字符
        return str.slice(-numChars);
    }
}